package com.xbongbong.pro.bi.commons.sql;

import com.xbongbong.pro.bi.commons.helper.CollectionHelper;
import com.xbongbong.pro.bi.commons.helper.StringHelper;

import java.util.Collection;
import java.util.Collections;

import static com.xbongbong.pro.bi.commons.constant.Constant.AND;
import static com.xbongbong.pro.bi.commons.constant.Constant.AND_PREFIX;
import static com.xbongbong.pro.bi.commons.constant.Constant.AS;
import static com.xbongbong.pro.bi.commons.constant.Constant.ASC;
import static com.xbongbong.pro.bi.commons.constant.Constant.DELETE_FROM;
import static com.xbongbong.pro.bi.commons.constant.Constant.DESC;
import static com.xbongbong.pro.bi.commons.constant.Constant.EQUAL;
import static com.xbongbong.pro.bi.commons.constant.Constant.EQUAL_SUFFIX;
import static com.xbongbong.pro.bi.commons.constant.Constant.FROM;
import static com.xbongbong.pro.bi.commons.constant.Constant.FULL_JOIN;
import static com.xbongbong.pro.bi.commons.constant.Constant.GROUP_BY;
import static com.xbongbong.pro.bi.commons.constant.Constant.GTE_SUFFIX;
import static com.xbongbong.pro.bi.commons.constant.Constant.GT_SUFFIX;
import static com.xbongbong.pro.bi.commons.constant.Constant.HAVING;
import static com.xbongbong.pro.bi.commons.constant.Constant.INNER_JOIN;
import static com.xbongbong.pro.bi.commons.constant.Constant.INSERT_INTO;
import static com.xbongbong.pro.bi.commons.constant.Constant.IN_SUFFIX;
import static com.xbongbong.pro.bi.commons.constant.Constant.IS_NOT_NULL_SUFFIX;
import static com.xbongbong.pro.bi.commons.constant.Constant.IS_NULL_SUFFIX;
import static com.xbongbong.pro.bi.commons.constant.Constant.LEFT_JOIN;
import static com.xbongbong.pro.bi.commons.constant.Constant.LIKE_KEY;
import static com.xbongbong.pro.bi.commons.constant.Constant.LIMIT;
import static com.xbongbong.pro.bi.commons.constant.Constant.LTE_SUFFIX;
import static com.xbongbong.pro.bi.commons.constant.Constant.LT_SUFFIX;
import static com.xbongbong.pro.bi.commons.constant.Constant.NOT_EQUAL_SUFFIX;
import static com.xbongbong.pro.bi.commons.constant.Constant.NOT_IN_SUFFIX;
import static com.xbongbong.pro.bi.commons.constant.Constant.NOT_LIKE_KEY;
import static com.xbongbong.pro.bi.commons.constant.Constant.OBJTYPE_ARRAY;
import static com.xbongbong.pro.bi.commons.constant.Constant.OBJTYPE_COLLECTION;
import static com.xbongbong.pro.bi.commons.constant.Constant.OFFSET;
import static com.xbongbong.pro.bi.commons.constant.Constant.ON;
import static com.xbongbong.pro.bi.commons.constant.Constant.ONE_SPACE;
import static com.xbongbong.pro.bi.commons.constant.Constant.OR;
import static com.xbongbong.pro.bi.commons.constant.Constant.ORDER_BY;
import static com.xbongbong.pro.bi.commons.constant.Constant.OR_PREFIX;
import static com.xbongbong.pro.bi.commons.constant.Constant.RIGHT_JOIN;
import static com.xbongbong.pro.bi.commons.constant.Constant.SELECT;
import static com.xbongbong.pro.bi.commons.constant.Constant.SET;
import static com.xbongbong.pro.bi.commons.constant.Constant.SPACE;
import static com.xbongbong.pro.bi.commons.constant.Constant.UNION;
import static com.xbongbong.pro.bi.commons.constant.Constant.UNION_ALL;
import static com.xbongbong.pro.bi.commons.constant.Constant.UPDATE;
import static com.xbongbong.pro.bi.commons.constant.Constant.VALUES;
import static com.xbongbong.pro.bi.commons.constant.Constant.WHERE;

/**
 * @author  gzt
 * @Description 构造链式sql
 * @Date 9:34 2022/5/24
 **/

public final class SqlBuilderHandler {

    /** 封装了SqlInfo、应用中提供的上下文参数、前缀等信息.由于这里是纯Java拼接,所以就没有xml的Node节点信息，初始为为null. */
    private BuildSource source;

    /**
     * 私有构造方法，构造时就初始化BuildSource相应的参数信息.
     */
    private SqlBuilderHandler() {
        this.source = new BuildSource(SqlInfo.newInstance());
    }

    /**
     * 开始的方法.
     * @return SqlBuilderHandler实例
     */
    public static SqlBuilderHandler start() {
        return new SqlBuilderHandler();
    }

    /**
     * 结束SQL拼接流程，并生成最终的sqlInfo信息.
     * @return sqlInfo
     */
    public SqlInfo end() {
        SqlInfo sqlInfo = this.source.getSqlInfo();
        sqlInfo.setSql(StringHelper.replaceBlank(sqlInfo.getJoin().toString()));
        return sqlInfo;
    }

    /**
     * 连接字符串.
     * @param sqlKey sql关键字
     * @param params 其他若干字符串参数
     */
    private SqlBuilderHandler concat(String sqlKey, String ... params) {
        this.source.getSqlInfo().getJoin().append(SPACE).append(sqlKey).append(SPACE);
        if (params != null && params.length > 0) {
            for (String s: params) {
                this.source.getSqlInfo().getJoin().append(s).append(SPACE);
            }
        }
        return this;
    }

    /**
     * 连接字符串.
     * @param sqlKey sql关键字
     * @param params 其他若干字符串参数
     */
    private SqlBuilderHandler concat(String sqlKey, boolean isSpace,String ... params) {
        if (!isSpace){
            this.source.getSqlInfo().getJoin().append(sqlKey);
        }else {
            this.source.getSqlInfo().getJoin().append(SPACE).append(sqlKey).append(SPACE);
        }
        if (params != null && params.length > 0) {
            for (String s: params) {
                    this.source.getSqlInfo().getJoin().append(s);
            }
        }
        return this;
    }

    /**
     * 连接字符串.
     * @param sqlKey sql关键字
     * @param params 其他若干字符串参数
     */
    private SqlBuilderHandler concat(int sqlKey, String ... params) {
        this.source.getSqlInfo().getJoin().append(SPACE).append(sqlKey).append(SPACE);
        if (params != null && params.length > 0) {
            for (String s: params) {
                this.source.getSqlInfo().getJoin().append(s).append(SPACE);
            }
        }
        return this;
    }


    private SqlBuilderHandler concat(String prefix,String suffix,Boolean isAddPreSuffix) {
        SqlBuilderHandler sqlBuilderHandler = SqlBuilderHandler.start();
        if (isAddPreSuffix){
            sqlBuilderHandler.append(prefix).append(this.source.getSqlInfo().getJoin().append(suffix).toString());
        }
        return sqlBuilderHandler;
    }

    /**
     * 连接字符串.
     * @param sqlKey sql关键字
     * @param params 其他若干字符串参数
     */
    private SqlBuilderHandler concatBuffer(StringBuffer sqlKey, String ... params) {
        this.source.getSqlInfo().getJoin().append(SPACE).append(sqlKey).append(SPACE);
        if (params != null && params.length > 0) {
            for (String s: params) {
                this.source.getSqlInfo().getJoin().append(s).append(SPACE);
            }
        }
        return this;
    }


    /**
     * 连接字符串.
     * @param sqlKey sql关键字
     * @param params 其他若干字符串参数
     */
    private SqlBuilderHandler concat(String sqlKey, Object ... params) {
        this.source.getSqlInfo().getJoin().append(SPACE).append(sqlKey).append(SPACE);
        if (params != null && params.length > 0) {
            for (Object s: params) {
                this.source.getSqlInfo().getJoin().append(s).append(SPACE);
            }
        }
        return this;
    }



    /**
     * 拼接并带上'INSERT_INTO'关键字的字符串.
     * @param text 文本
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler insertInto(String text) {
        return concat(INSERT_INTO , text);
    }

    /**
     * 拼接并带上'VALUES'关键字的字符串.
     * @param text 文本
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler values(String text) {
        return concat(VALUES , text);
    }

    /**
     * 拼接并带上'DELETE FROM'关键字的字符串.
     * @param text 文本
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler deleteFrom(String text) {
        return concat(DELETE_FROM , text);
    }

    /**
     * 拼接并带上'UPDATE'关键字的字符串.
     * @param text 文本
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler update(String text) {
        return concat(UPDATE, text);
    }

    /**
     * 拼接并带上'SELECT'关键字的字符串.
     * @param text 文本
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler select(String text) {
        return concat(SELECT, text);
    }


    /**
     * 拼接并带上'SELECT'关键字的字符串.
     * @param text 文本
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler append(String text) {
        return concat(text,null);
    }

    /**
     * 拼接并带上'SELECT'关键字的字符串.
     * @param text 文本
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler append(String text,boolean isSpace) {
        return concat(text,isSpace,null);
    }

    /**
     * 拼接并带上'SELECT'关键字的字符串.
     * @param num 文本
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler append(int num) {
        return concat(num,null);
    }

    /**
     * 拼接并带上'SELECT'关键字的字符串.
     * @param stringBuffer 文本
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler append(StringBuffer stringBuffer) {
        return concatBuffer(stringBuffer,null);
    }

    /**
     * 拼接并带上'SELECT'关键字的字符串.
     * @param params 文本
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler append(String... params) {
        return concat(null,params);
    }

    /**
     * 拼接并带上'SELECT'关键字的字符串.
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler append(String prefix,String suffix,Boolean isAddPreSuffix) {
        return concat(prefix,suffix,isAddPreSuffix);
    }

    /**
     * 拼接并带上'FROM'关键字的字符串.
     * @param text 文本
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler from(String text) {
        return concat(FROM, text);
    }

    /**
     * 拼接并带上'WHERE'关键字的字符串和动态参数.
     * @param text 文本
     * @param value 参数值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler where(String text, Object... value) {
        concat(WHERE, text);
        return this.param(value);
    }

    /**
     * 拼接并带上'AND'关键字的字符串.
     * @param text 文本
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler and(String text) {
        return concat(AND, text);
    }

    /**
     * 拼接并带上'AND'关键字的字符串.
     * @param text 数组
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler and(String... text) {
        return concat(AND, text);
    }

    /**
     * 拼接并带上'AND'关键字的字符串.
     * @param text 数组
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andNoSpace(boolean isSpace,String... text) {
        return concat(AND,false,text);
    }

    /**
     * 拼接并带上'AND'关键字的字符串.
     * @param text 数组
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler and(Object... text) {
        return concat(AND, text);
    }

    /**
     * 拼接并带上'OR'关键字的字符串.
     * @param text 文本
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler or(String text) {
        return concat(OR, text);
    }

    /**
     * 拼接并带上'AS'关键字的字符串.
     * @param text 文本
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler as(String text) {
        return concat(AS, text);
    }

    /**
     * 拼接并带上'AS'关键字的字符串.
     * @param text 文本
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler set(String text) {
        return concat(SET, text);
    }

    /**
     * 拼接并带上'INNER JOIN'关键字的字符串.
     * @param text 文本
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler innerJoin(String text) {
        return concat(INNER_JOIN, text);
    }

    /**
     * 拼接并带上'LEFT JOIN'关键字的字符串.
     * @param text 文本
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler leftJoin(String text) {
        return concat(LEFT_JOIN, text);
    }

    /**
     * 拼接并带上'RIGHT JOIN'关键字的字符串.
     * @param text 文本
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler rightJoin(String text) {
        return concat(RIGHT_JOIN, text);
    }

    /**
     * 拼接并带上'FULL JOIN'关键字的字符串.
     * @param text 文本
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler fullJoin(String text) {
        return concat(FULL_JOIN, text);
    }

    /**
     * 拼接并带上'ON'关键字的字符串.
     * @param text 文本
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler on(String text) {
        return concat(ON, text);
    }

    /**
     * 拼接并带上'ORDER BY'关键字的字符串.
     * @param text 文本
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orderBy(String text) {
        return concat(ORDER_BY, text);
    }

    /**
     * 拼接并带上'GROUP BY'关键字的字符串.
     * @param text 文本
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler groupBy(String text) {
        return concat(GROUP_BY, text);
    }

    /**
     * 拼接并带上'HAVING'关键字的字符串.
     * @param text 文本
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler having(String text) {
        return concat(HAVING, text);
    }

    /**
     * 拼接并带上'LIMIT'关键字的字符串.
     * @param text 文本
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler limit(String text) {
        return concat(LIMIT, text);
    }

    /**
     * 拼接并带上'OFFSET'关键字的字符串.
     * @param text 文本
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler offset(String text) {
        return concat(OFFSET, text);
    }

    /**
     * 拼接并带上'ASC'关键字的字符串.
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler asc() {
        return concat(ASC);
    }

    /**
     * 拼接并带上'DESC'关键字的字符串.
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler desc() {
        return concat(DESC);
    }

    /**
     * 拼接并带上'UNION'关键字的字符串.
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler union() {
        return concat(UNION);
    }


    /**
     * 拼接并带上'UNION ALL'关键字的字符串.
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler unionAll() {
        return concat(UNION_ALL);
    }

    /**
     * 在sql后追加任何文本字符串，后可追加自定义可变参数.
     * @param text 文本
     * @param values 可变参数数组
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler text(String text, Object... values) {
        this.source.getSqlInfo().getJoin().append(text);
        this.appendParams(values, OBJTYPE_ARRAY);
        return this;
    }

    /**
     * 在sql后追加任何文本字符串，后可追加自定义可变参数，如果match为true时，才生成此SQL文本和参数.
     * @param match 匹配条件
     * @param text 文本
     * @param values 可变参数数组
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler text(boolean match, String text, Object... values) {
        return match ? text(text, values) : this;
    }

    /**
     * 在sql的参数集合后追加任何的数组.
     * @param value 值
     * @param objType 对象类型那
     * @return SqlBuilderHandler实例
     */
    private SqlBuilderHandler appendParams(Object value, int objType) {
        Object[] values = CollectionHelper.toArray(value, objType);
        if (CollectionHelper.isNotEmpty(values)) {
            Collections.addAll(this.source.getSqlInfo().getParams(), values);
        }
        return this;
    }

    /**
     * 在sql的参数集合后追加不定对象个数的数组.
     * @param values 不定个数的值，也是数组
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler param(Object... values) {
        return this.appendParams(values, OBJTYPE_ARRAY);
    }

    /**
     * 在sql的参数集合后追加任何的一个集合.
     * @param values 不定个数的值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler param(Collection<?> values) {
        return this.appendParams(values, OBJTYPE_COLLECTION);
    }

    /**
     * 执行自定义的任意操作.
     * @param action 执行when条件中的方法
     * @return SqlBuilderHandler实例
     */
   /* public SqlBuilderHandler doAnything(ICustomAction action) {
        SqlInfo sqlInfo = this.source.getSqlInfo();
        action.execute(sqlInfo.getJoin(), sqlInfo.getParams());
        return this;
    }*/

    /**
     * 当匹配match条件为true时，才执行自定义的任意操作.
     * @param match 匹配条件
     * @param action 执行when条件中的方法
     * @return SqlBuilderHandler实例
     */
    /*public SqlBuilderHandler doAnything(boolean match, ICustomAction action) {
        return match ? this.doAnything(action) : this;
    }*/

    /**
     * 执行生成等值查询SQL片段的方法.
     * @param prefix 前缀
     * @param field 数据库字段
     * @param value 值
     * @param suffix 后缀
     * @param match 是否匹配
     * @return SqlBuilderHandler实例的当前实例
     */
    private SqlBuilderHandler doNormal(String prefix, String field, Object value, String suffix, boolean match) {
        if (match) {
            SqlInfoBuilder.newInstace(this.source.setPrefix(prefix)).buildNormalSql(field, value, suffix);
            this.source.resetPrefix();
        }
        return this;
    }

    /**
     * 执行生成等值查询SQL片段的方法.
     * @param prefix 前缀
     * @param field 数据库字段
     * @param value 值
     * @param suffix 后缀
     * @return SqlBuilderHandler实例的当前实例
     */
    private SqlBuilderHandler doNormal(String prefix, String field, Object value, String suffix) {
            SqlInfoBuilder.newInstace(this.source.setPrefix(prefix)).buildNormalSqlNoParam(field, value, suffix);
            this.source.resetPrefix();
        return this;
    }


    /**
     * 执行生成like模糊查询SQL片段的方法.
     * @param prefix 前缀
     * @param field 数据库字段
     * @param value 值
     * @param match 是否匹配
     * @param positive true则表示是like，否则是not like
     * @return SqlBuilderHandler实例的当前实例
     */
    private SqlBuilderHandler doLike(String prefix, String field, Object value, boolean match, boolean positive) {
        if (match) {
            String suffix = positive ? LIKE_KEY : NOT_LIKE_KEY;
            SqlInfoBuilder.newInstace(this.source.setPrefix(prefix).setSuffix(suffix)).buildLikeSql(field, value);
            this.source.resetPrefix();
        }
        return this;
    }

    /**
     * 执行根据传入模式来生成like匹配SQL片段的方法.
     * @param prefix 前缀
     * @param field 数据库字段
     * @param pattern 值
     * @param match 是否匹配
     * @param positive true则表示是like，否则是not like
     * @return SqlBuilderHandler实例的当前实例
     */
    private SqlBuilderHandler doLikePattern(String prefix, String field, String pattern, boolean match, boolean positive) {
        if (match) {
            String suffix = positive ? LIKE_KEY : NOT_LIKE_KEY;
            SqlInfoBuilder.newInstace(this.source.setPrefix(prefix).setSuffix(suffix))
                    .buildLikePatternSql(field, pattern);
            this.source.resetPrefix();
        }
        return this;
    }

    /**
     * 执行生成like模糊查询SQL片段的方法.
     * @param prefix 前缀
     * @param field 数据库字段
     * @param startValue 值
     * @param endValue 值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例的当前实例
     */
    private SqlBuilderHandler doBetween(String prefix, String field, Object startValue, Object endValue, boolean match) {
        if (match) {
            SqlInfoBuilder.newInstace(this.source.setPrefix(prefix)).buildBetweenSql(field, startValue, endValue);
            this.source.resetPrefix();
        }
        return this;
    }

    /**
     * 执行生成in范围查询SQL片段的方法,如果是集合或数组，则执行生成，否则抛出异常.
     * @param prefix 前缀
     * @param field 数据库字段
     * @param value 数组的值
     * @param match 是否匹配
     * @param objType 对象类型，取自java中以OBJTYPE开头的类型
     * @param positive true则表示是in，否则是not in
     * @return SqlBuilderHandler实例的当前实例
     */
    @SuppressWarnings("unchecked")
    private SqlBuilderHandler doInByType(String prefix, String field, Object value,
            boolean match, int objType, boolean positive) {
        if (match) {
            // 赋予source对象in SQL片段的前缀和后缀操作符.
            this.source.setPrefix(prefix).setSuffix(positive ? IN_SUFFIX : NOT_IN_SUFFIX);
            // 根据对象类型调用对应的生成in查询的sql片段方法,否则抛出类型不符合的异常
            switch (objType) {
                // 如果类型是数组.
                case OBJTYPE_ARRAY:
                    SqlInfoBuilder.newInstace(source).buildInSql(field, (Object[]) value);
                    break;
                // 如果类型是Java集合.
                case OBJTYPE_COLLECTION:
                    SqlInfoBuilder.newInstace(source,true).buildInSqlByCollection(field, (Collection<Object>) value);
                    break;
                default:
                    //throw new XbbException(ErrorCodeEnum.API_ERROR_100005,"in查询的值不是有效的集合或数组!");
            }
            this.source.resetPrefix();
        }
        return this;
    }

    /**
     * 执行生成in范围查询SQL片段的方法.
     * @param prefix 前缀
     * @param field 数据库字段
     * @param values 数组的值
     * @param match 是否匹配
     * @param positive true则表示是in，否则是not in
     * @return SqlBuilderHandler实例的当前实例
     */
    private SqlBuilderHandler doIn(String prefix, String field, Object[] values, boolean match, boolean positive) {
        return this.doInByType(prefix, field, values, match, OBJTYPE_ARRAY, positive);
    }

    /**
     * 执行生成in范围查询SQL片段的方法.
     * @param prefix 前缀
     * @param field 数据库字段
     * @param values 集合的值
     * @param match 是否匹配
     * @param positive true则表示是in，否则是not in
     * @return SqlBuilderHandler实例的当前实例
     */
    private SqlBuilderHandler doIn(String prefix, String field, Collection<?> values, boolean match, boolean positive) {
        return this.doInByType(prefix, field, values, match, OBJTYPE_COLLECTION, positive);
    }

    /**
     * 执行生成" IS NULL "SQL片段的方法.
     * @param prefix 前缀
     * @param field 数据库字段
     * @param match 是否匹配
     * @param positive true则表示是 IS NULL，否则是IS NOT NULL
     * @return SqlBuilderHandler实例的当前实例
     */
    private SqlBuilderHandler doIsNull(String prefix, String field, boolean match, boolean positive) {
        if (match) {
            // 判断是"IS NULL"还是"IS NOT NULL"来设置source实例.
            this.source = this.source.setPrefix(prefix)
                    .setSuffix(positive ? IS_NULL_SUFFIX : IS_NOT_NULL_SUFFIX);
            SqlInfoBuilder.newInstace(this.source).buildIsNullSql(field);
            this.source.resetPrefix();
        }
        return this;
    }

    /**
     * 生成等值查询的SQL片段.
     * @param field 数据库字段
     * @param value 值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler equalParam(String field, Object value) {
        return this.doNormal(ONE_SPACE, field, value, EQUAL_SUFFIX,true);
    }

    /**
     * 生成等值查询的SQL片段.
     * @param field 数据库字段
     * @param value 值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler equal(String field, Object value) {
        return this.doNormal(ONE_SPACE, field, value, EQUAL);
    }

    /**
     * 生成等值查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param value 值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler equal(String field, Object value, boolean match) {
        return this.doNormal(ONE_SPACE, field, value, EQUAL_SUFFIX, match);
    }

    /**
     * 生成带" AND "前缀等值查询的SQL片段.
     * @param field 数据库字段
     * @param value 值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andEqual(String field, Object value) {
        return this.doNormal(AND_PREFIX, field, value, EQUAL, true);
    }

    /**
     * 生成带" AND "前缀等值查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param value 值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andEqual(String field, Object value, boolean match) {
        return this.doNormal(AND_PREFIX, field, value, EQUAL_SUFFIX, match);
    }

    /**
     * 生成带" OR "前缀等值查询的SQL片段.
     * @param field 数据库字段
     * @param value 值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orEqual(String field, Object value) {
        return this.doNormal(OR_PREFIX, field, value, EQUAL_SUFFIX, true);
    }

    /**
     * 生成带" OR "前缀等值查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param value 值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orEqual(String field, Object value, boolean match) {
        return this.doNormal(OR_PREFIX, field, value, EQUAL_SUFFIX, match);
    }

    /**
     * 生成不等查询的SQL片段.
     * @param field 数据库字段
     * @param value 值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler notEqual(String field, Object value) {
        return this.doNormal(ONE_SPACE, field, value, NOT_EQUAL_SUFFIX,true);
    }

    /**
     * 生成不等查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param value 值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler notEqual(String field, Object value, boolean match) {
        return this.doNormal(ONE_SPACE, field, value, NOT_EQUAL_SUFFIX, match);
    }

    /**
     * 生成带" AND "前缀不等查询的SQL片段.
     * @param field 数据库字段
     * @param value 值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andNotEqual(String field, Object value) {
        return this.doNormal(AND_PREFIX, field, value, NOT_EQUAL_SUFFIX, true);
    }

    /**
     * 生成带" AND "前缀不等查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param value 值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andNotEqual(String field, Object value, boolean match) {
        return this.doNormal(AND_PREFIX, field, value, NOT_EQUAL_SUFFIX, match);
    }

    /**
     * 生成带" OR "前缀不等查询的SQL片段.
     * @param field 数据库字段
     * @param value 值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orNotEqual(String field, Object value) {
        return this.doNormal(OR_PREFIX, field, value, NOT_EQUAL_SUFFIX, true);
    }

    /**
     * 生成带" OR "前缀不等查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param value 值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orNotEqual(String field, Object value, boolean match) {
        return this.doNormal(OR_PREFIX, field, value, NOT_EQUAL_SUFFIX, match);
    }

    /**
     * 生成大于查询的SQL片段.
     * @param field 数据库字段
     * @param value 值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler moreThan(String field, Object value) {
        return this.doNormal(ONE_SPACE, field, value, GT_SUFFIX, true);
    }

    /**
     * 生成大于查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param value 值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler moreThan(String field, Object value, boolean match) {
        return this.doNormal(ONE_SPACE, field, value, GT_SUFFIX, match);
    }

    /**
     * 生成带" AND "前缀大于查询的SQL片段.
     * @param field 数据库字段
     * @param value 值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andMoreThan(String field, Object value) {
        return this.doNormal(AND_PREFIX, field, value, GT_SUFFIX, true);
    }

    /**
     * 生成带" AND "前缀大于查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param value 值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andMoreThan(String field, Object value, boolean match) {
        return this.doNormal(AND_PREFIX, field, value, GT_SUFFIX, match);
    }

    /**
     * 生成带" OR "前缀大于查询的SQL片段.
     * @param field 数据库字段
     * @param value 值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orMoreThan(String field, Object value) {
        return this.doNormal(OR_PREFIX, field, value, GT_SUFFIX, true);
    }

    /**
     * 生成带" OR "前缀大于查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param value 值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orMoreThan(String field, Object value, boolean match) {
        return this.doNormal(OR_PREFIX, field, value, GT_SUFFIX, match);
    }

    /**
     * 生成小于查询的SQL片段.
     * @param field 数据库字段
     * @param value 值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler lessThan(String field, Object value) {
        return this.doNormal(ONE_SPACE, field, value, LT_SUFFIX, true);
    }

    /**
     * 生成小于查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param value 值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler lessThan(String field, Object value, boolean match) {
        return this.doNormal(ONE_SPACE, field, value, LT_SUFFIX, match);
    }

    /**
     * 生成带" AND "前缀小于查询的SQL片段.
     * @param field 数据库字段
     * @param value 值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andLessThan(String field, Object value) {
        return this.doNormal(AND_PREFIX, field, value, LT_SUFFIX, true);
    }

    /**
     * 生成带" AND "前缀小于查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param value 值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andLessThan(String field, Object value, boolean match) {
        return this.doNormal(AND_PREFIX, field, value, LT_SUFFIX, match);
    }

    /**
     * 生成带" OR "前缀小于查询的SQL片段.
     * @param field 数据库字段
     * @param value 值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orLessThan(String field, Object value) {
        return this.doNormal(OR_PREFIX, field, value, LT_SUFFIX, true);
    }

    /**
     * 生成带" OR "前缀小于查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param value 值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orLessThan(String field, Object value, boolean match) {
        return this.doNormal(OR_PREFIX, field, value, LT_SUFFIX, match);
    }

    /**
     * 生成大于等于查询的SQL片段.
     * @param field 数据库字段
     * @param value 值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler moreEqual(String field, Object value) {
        return this.doNormal(ONE_SPACE, field, value, GTE_SUFFIX, true);
    }

    /**
     * 生成大于等于查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param value 值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler moreEqual(String field, Object value, boolean match) {
        return this.doNormal(ONE_SPACE, field, value, GTE_SUFFIX, match);
    }

    /**
     * 生成带" AND "前缀大于等于查询的SQL片段.
     * @param field 数据库字段
     * @param value 值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andMoreEqual(String field, Object value) {
        return this.doNormal(AND_PREFIX, field, value, GTE_SUFFIX, true);
    }

    /**
     * 生成带" AND "前缀大于等于查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param value 值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andMoreEqual(String field, Object value, boolean match) {
        return this.doNormal(AND_PREFIX, field, value, GTE_SUFFIX, match);
    }

    /**
     * 生成带" OR "前缀大于等于查询的SQL片段.
     * @param field 数据库字段
     * @param value 值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orMoreEqual(String field, Object value) {
        return this.doNormal(OR_PREFIX, field, value, GTE_SUFFIX, true);
    }

    /**
     * 生成带" OR "前缀大于等于查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param value 值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orMoreEqual(String field, Object value, boolean match) {
        return this.doNormal(OR_PREFIX, field, value, GTE_SUFFIX, match);
    }

    /**
     * 生成小于等于查询的SQL片段.
     * @param field 数据库字段
     * @param value 值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler lessEqual(String field, Object value) {
        return this.doNormal(ONE_SPACE, field, value, LTE_SUFFIX, true);
    }

    /**
     * 生成小于等于查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param value 值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler lessEqual(String field, Object value, boolean match) {
        return this.doNormal(ONE_SPACE, field, value, LTE_SUFFIX, match);
    }

    /**
     * 生成带" AND "前缀小于等于查询的SQL片段.
     * @param field 数据库字段
     * @param value 值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andLessEqual(String field, Object value) {
        return this.doNormal(AND_PREFIX, field, value, LTE_SUFFIX, true);
    }

    /**
     * 生成带" AND "前缀小于等于查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param value 值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andLessEqual(String field, Object value, boolean match) {
        return this.doNormal(AND_PREFIX, field, value, LTE_SUFFIX, match);
    }

    /**
     * 生成带" OR "前缀小于等于查询的SQL片段.
     * @param field 数据库字段
     * @param value 值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orLessEqual(String field, Object value) {
        return this.doNormal(OR_PREFIX, field, value, LTE_SUFFIX, true);
    }

    /**
     * 生成带" OR "前缀小于等于查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param value 值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orLessEqual(String field, Object value, boolean match) {
        return this.doNormal(OR_PREFIX, field, value, LTE_SUFFIX, match);
    }

    /**
     * 生成like模糊查询的SQL片段.
     * @param field 数据库字段
     * @param value 值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler like(String field, Object value) {
        return this.doLike(ONE_SPACE, field, value, true, true);
    }

    /**
     * 生成like模糊查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param value 值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler like(String field, Object value, boolean match) {
        return this.doLike(ONE_SPACE, field, value, match, true);
    }

    /**
     * 生成带" AND "前缀的like模糊查询的SQL片段.
     * @param field 数据库字段
     * @param value 值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andLike(String field, Object value) {
        return this.doLike(AND_PREFIX, field, value, true, true);
    }

    /**
     * 生成带" AND "前缀的like模糊查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param value 值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andLike(String field, Object value, boolean match) {
        return this.doLike(AND_PREFIX, field, value, match, true);
    }

    /**
     * 生成带" OR "前缀的like模糊查询的SQL片段.
     * @param field 数据库字段
     * @param value 值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orLike(String field, Object value) {
        return this.doLike(OR_PREFIX, field, value, true, true);
    }

    /**
     * 生成带" OR "前缀的like模糊查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param value 值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orLike(String field, Object value, boolean match) {
        return this.doLike(OR_PREFIX, field, value, match, true);
    }

    /**
     * 生成" NOT LIKE "模糊查询的SQL片段.
     * <p>示例：传入 {"b.title", "Spring"} 两个参数，生成的SQL片段为：" b.title NOT LIKE ? ", SQL参数为:{"%Spring%"}</p>
     *
     * @param field 数据库字段
     * @param value 值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler notLike(String field, Object value) {
        return this.doLike(ONE_SPACE, field, value, true, false);
    }

    /**
     * 生成" NOT LIKE "模糊查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * <p>示例：传入 {"b.title", "Spring", true} 三个参数，生成的SQL片段为：" b.title NOT LIKE ? ", SQL参数为:{"%Spring%"}</p>
     *
     * @param field 数据库字段
     * @param value 值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler notLike(String field, Object value, boolean match) {
        return this.doLike(ONE_SPACE, field, value, match, false);
    }

    /**
     * 生成带" AND "前缀的" NOT LIKE "模糊查询的SQL片段.
     * <p>示例：传入 {"b.title", "Spring"} 两个参数，生成的SQL片段为：" AND b.title NOT LIKE ? ", SQL参数为:{"%Spring%"}</p>
     *
     * @param field 数据库字段
     * @param value 值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andNotLike(String field, Object value) {
        return this.doLike(AND_PREFIX, field, value, true, false);
    }

    /**
     * 生成带" AND "前缀的" NOT LIKE "模糊查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * <p>示例：传入 {"b.title", "Spring", true} 三个参数，生成的SQL片段为：" AND b.title NOT LIKE ? ", SQL参数为:{"%Spring%"}</p>
     *
     * @param field 数据库字段
     * @param value 值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andNotLike(String field, Object value, boolean match) {
        return this.doLike(AND_PREFIX, field, value, match, false);
    }

    /**
     * 生成带" OR "前缀的" NOT LIKE "模糊查询的SQL片段.
     * <p>示例：传入 {"b.title", "Spring"} 两个参数，生成的SQL片段为：" OR b.title NOT LIKE ? ", SQL参数为:{"%Spring%"}</p>
     *
     * @param field 数据库字段
     * @param value 值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orNotLike(String field, Object value) {
        return this.doLike(OR_PREFIX, field, value, true, false);
    }

    /**
     * 生成带" OR "前缀的" NOT LIKE "模糊查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * <p>示例：传入 {"b.title", "Spring", true} 三个参数，生成的SQL片段为：" OR b.title NOT LIKE ? ", SQL参数为:{"%Spring%"}</p>
     *
     * @param field 数据库字段
     * @param value 值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orNotLike(String field, Object value, boolean match) {
        return this.doLike(OR_PREFIX, field, value, match, false);
    }

    /**
     * 根据指定的模式字符串生成like模糊查询的SQL片段.
     * <p>示例：传入 {"b.title", "Java%"} 两个参数，生成的SQL片段为：" b.title LIKE 'Java%' "</p>
     *
     * @param field 数据库字段
     * @param pattern 模式字符串
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler likePattern(String field, String pattern) {
        return this.doLikePattern(ONE_SPACE, field, pattern, true, true);
    }

    /**
     * 根据指定的模式字符串生成like模糊查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * <p>示例：传入 {"b.title", "Java%", true} 三个参数，生成的SQL片段为：" b.title LIKE 'Java%' "</p>
     * <p>示例：传入 {"b.title", "Java%", false} 三个参数，生成的SQL片段为空字符串.</p>
     *
     * @param field 数据库字段
     * @param pattern 模式字符串
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler likePattern(String field, String pattern, boolean match) {
        return this.doLikePattern(ONE_SPACE, field, pattern, match, true);
    }

    /**
     * 根据指定的模式字符串生成带" AND "前缀的like模糊查询的SQL片段.
     * <p>示例：传入 {"b.title", "Java%"} 两个参数，生成的SQL片段为：" AND b.title LIKE 'Java%' "</p>
     *
     * @param field 数据库字段
     * @param pattern 模式字符串
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andLikePattern(String field, String pattern) {
        return this.doLikePattern(AND_PREFIX, field, pattern, true, true);
    }

    /**
     * 根据指定的模式字符串生成带" AND "前缀的like模糊查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * <p>示例：传入 {"b.title", "Java%", true} 三个参数，生成的SQL片段为：" AND b.title LIKE 'Java%' "</p>
     * <p>示例：传入 {"b.title", "Java%", false} 三个参数，生成的SQL片段为空字符串.</p>
     *
     * @param field 数据库字段
     * @param pattern 模式字符串
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andLikePattern(String field, String pattern, boolean match) {
        return this.doLikePattern(AND_PREFIX, field, pattern, match, true);
    }

    /**
     * 根据指定的模式字符串生成带" OR "前缀的like模糊查询的SQL片段.
     * <p>示例：传入 {"b.title", "Java%"} 两个参数，生成的SQL片段为：" OR b.title LIKE 'Java%' "</p>
     *
     * @param field 数据库字段
     * @param pattern 模式字符串
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orLikePattern(String field, String pattern) {
        return this.doLikePattern(OR_PREFIX, field, pattern, true, true);
    }

    /**
     * 根据指定的模式字符串生成带" OR "前缀的like模糊查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * <p>示例：传入 {"b.title", "Java%", true} 三个参数，生成的SQL片段为：" OR b.title LIKE 'Java%' "</p>
     * <p>示例：传入 {"b.title", "Java%", false} 三个参数，生成的SQL片段为空字符串.</p>
     *
     * @param field 数据库字段
     * @param pattern 模式字符串
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orLikePattern(String field, String pattern, boolean match) {
        return this.doLikePattern(OR_PREFIX, field, pattern, match, true);
    }

    /**
     * 根据指定的模式字符串生成" NOT LIKE "模糊查询的SQL片段.
     * <p>示例：传入 {"b.title", "Java%"} 两个参数，生成的SQL片段为：" b.title NOT LIKE 'Java%' "</p>
     *
     * @param field 数据库字段
     * @param pattern 模式字符串
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler notLikePattern(String field, String pattern) {
        return this.doLikePattern(ONE_SPACE, field, pattern, true, false);
    }

    /**
     * 根据指定的模式字符串生成" NOT LIKE "模糊查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * <p>示例：传入 {"b.title", "Java%", true} 三个参数，生成的SQL片段为：" b.title NOT LIKE 'Java%' "</p>
     * <p>示例：传入 {"b.title", "Java%", false} 三个参数，生成的SQL片段为空字符串.</p>
     *
     * @param field 数据库字段
     * @param pattern 模式字符串
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler notLikePattern(String field, String pattern, boolean match) {
        return this.doLikePattern(ONE_SPACE, field, pattern, match, false);
    }

    /**
     * 根据指定的模式字符串生成带" AND "前缀的" NOT LIKE "模糊查询的SQL片段.
     * <p>示例：传入 {"b.title", "Java%"} 两个参数，生成的SQL片段为：" AND b.title NOT LIKE 'Java%' "</p>
     *
     * @param field 数据库字段
     * @param pattern 模式字符串
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andNotLikePattern(String field, String pattern) {
        return this.doLikePattern(AND_PREFIX, field, pattern, true, false);
    }

    /**
     * 根据指定的模式字符串生成带" AND "前缀的" NOT LIKE "模糊查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * <p>示例：传入 {"b.title", "Java%", true} 三个参数，生成的SQL片段为：" AND b.title NOT LIKE 'Java%' "</p>
     * <p>示例：传入 {"b.title", "Java%", false} 三个参数，生成的SQL片段为空字符串.</p>
     *
     * @param field 数据库字段
     * @param pattern 模式字符串
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andNotLikePattern(String field, String pattern, boolean match) {
        return this.doLikePattern(AND_PREFIX, field, pattern, match, false);
    }

    /**
     * 根据指定的模式字符串生成带" OR "前缀的" NOT LIKE "模糊查询的SQL片段.
     * <p>示例：传入 {"b.title", "Java%"} 两个参数，生成的SQL片段为：" OR b.title NOT LIKE 'Java%' "</p>
     *
     * @param field 数据库字段
     * @param pattern 模式字符串
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orNotLikePattern(String field, String pattern) {
        return this.doLikePattern(OR_PREFIX, field, pattern, true, false);
    }

    /**
     * 根据指定的模式字符串生成带" OR "前缀的" NOT LIKE "模糊查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * <p>示例：传入 {"b.title", "Java%", true} 三个参数，生成的SQL片段为：" OR b.title NOT LIKE 'Java%' "</p>
     * <p>示例：传入 {"b.title", "Java%", false} 三个参数，生成的SQL片段为空字符串.</p>
     *
     * @param field 数据库字段
     * @param pattern 模式字符串
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orNotLikePattern(String field, String pattern, boolean match) {
        return this.doLikePattern(OR_PREFIX, field, pattern, match, false);
    }

    /**
     * 生成between区间查询的SQL片段(当某一个值为null时，会是大于等于或小于等于的情形).
     * @param field 数据库字段
     * @param startValue 开始值
     * @param endValue 结束值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler between(String field, Object startValue, Object endValue) {
        return this.doBetween(ONE_SPACE, field, startValue, endValue, true);
    }

    /**
     * 生成between区间查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成(当某一个值为null时，会是大于等于或小于等于的情形).
     * @param field 数据库字段
     * @param startValue 开始值
     * @param endValue 结束值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler between(String field, Object startValue, Object endValue, boolean match) {
        return this.doBetween(ONE_SPACE, field, startValue, endValue, match);
    }

    /**
     * 生成带" AND "前缀的between区间查询的SQL片段(当某一个值为null时，会是大于等于或小于等于的情形).
     * @param field 数据库字段
     * @param startValue 开始值
     * @param endValue 结束值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andBetween(String field, Object startValue, Object endValue) {
        return this.doBetween(AND_PREFIX, field, startValue, endValue, true);
    }

    /**
     * 生成带" AND "前缀的between区间查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成(当某一个值为null时，会是大于等于或小于等于的情形).
     * @param field 数据库字段
     * @param startValue 开始值
     * @param endValue 结束值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andBetween(String field, Object startValue, Object endValue, boolean match) {
        return this.doBetween(AND_PREFIX, field, startValue, endValue, match);
    }

    /**
     * 生成带" OR "前缀的between区间查询的SQL片段(当某一个值为null时，会是大于等于或小于等于的情形).
     * @param field 数据库字段
     * @param startValue 开始值
     * @param endValue 结束值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orBetween(String field, Object startValue, Object endValue) {
        return this.doBetween(OR_PREFIX, field, startValue, endValue, true);
    }

    /**
     * 生成带" OR "前缀的between区间查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成(当某一个值为null时，会是大于等于或小于等于的情形).
     * @param field 数据库字段
     * @param startValue 开始值
     * @param endValue 结束值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orBetween(String field, Object startValue, Object endValue, boolean match) {
        return this.doBetween(OR_PREFIX, field, startValue, endValue, match);
    }

    /**
     * 生成in范围查询的SQL片段.
     * @param field 数据库字段
     * @param values 数组的值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler in(String field, Object[] values) {
        return this.doIn(ONE_SPACE, field, values, true, true);
    }

    /**
     * 生成in范围查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param values 数组的值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler in(String field, Object[] values, boolean match) {
        return this.doIn(ONE_SPACE, field, values, match, true);
    }

    /**
     * 生成in范围查询的SQL片段.
     * @param field 数据库字段
     * @param values 集合的值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler in(String field, Collection<?> values) {
        return this.doIn(ONE_SPACE, field, values, true, true);
    }

    /**
     * 生成in范围查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param values 集合的值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler in(String field, Collection<?> values, boolean match) {
        return this.doIn(ONE_SPACE, field, values, match, true);
    }

    /**
     * 生成带" AND "前缀的in范围查询的SQL片段.
     * @param field 数据库字段
     * @param values 数组的值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andIn(String field, Object[] values) {
        return this.doIn(AND_PREFIX, field, values, true, true);
    }

    /**
     * 生成带" AND "前缀的in范围查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param values 数组的值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andIn(String field, Object[] values, boolean match) {
        return this.doIn(AND_PREFIX, field, values, match, true);
    }

    /**
     * 生成带" AND "前缀的in范围查询的SQL片段.
     * @param field 数据库字段
     * @param values 集合的值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andIn(String field, Collection<?> values) {
        return this.doIn(AND_PREFIX, field, values, true, true);
    }

    /**
     * 生成带" AND "前缀的in范围查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param values 集合的值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andIn(String field, Collection<?> values, boolean match) {
        return this.doIn(AND_PREFIX, field, values, match, true);
    }

    /**
     * 生成带" OR "前缀的in范围查询的SQL片段.
     * @param field 数据库字段
     * @param values 数组的值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orIn(String field, Object[] values) {
        return this.doIn(OR_PREFIX, field, values, true, true);
    }

    /**
     * 生成带" OR "前缀的in范围查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param values 数组的值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orIn(String field, Object[] values, boolean match) {
        return this.doIn(OR_PREFIX, field, values, match, true);
    }

    /**
     * 生成带" OR "前缀的in范围查询的SQL片段.
     * @param field 数据库字段
     * @param values 集合的值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orIn(String field, Collection<?> values) {
        return this.doIn(OR_PREFIX, field, values, true, true);
    }

    /**
     * 生成带" OR "前缀的in范围查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param values 集合的值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orIn(String field, Collection<?> values, boolean match) {
        return this.doIn(OR_PREFIX, field, values, match, true);
    }

    /**
     * 生成" NOT IN "范围查询的SQL片段.
     * @param field 数据库字段
     * @param values 数组的值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler notIn(String field, Object[] values) {
        return this.doIn(ONE_SPACE, field, values, true, false);
    }

    /**
     * 生成" NOT IN "范围查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param values 数组的值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler notIn(String field, Object[] values, boolean match) {
        return this.doIn(ONE_SPACE, field, values, match, false);
    }

    /**
     * 生成" NOT IN "范围查询的SQL片段.
     * @param field 数据库字段
     * @param values 集合的值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler notIn(String field, Collection<?> values) {
        return this.doIn(ONE_SPACE, field, values, true, false);
    }

    /**
     * 生成" NOT IN "范围查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param values 集合的值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler notIn(String field, Collection<?> values, boolean match) {
        return this.doIn(ONE_SPACE, field, values, match, false);
    }

    /**
     * 生成带" AND "前缀的" NOT IN "范围查询的SQL片段.
     * @param field 数据库字段
     * @param values 数组的值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andNotIn(String field, Object[] values) {
        return this.doIn(AND_PREFIX, field, values, true, false);
    }

    /**
     * 生成带" AND "前缀的" NOT IN "范围查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param values 数组的值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andNotIn(String field, Object[] values, boolean match) {
        return this.doIn(AND_PREFIX, field, values, match, false);
    }

    /**
     * 生成带" AND "前缀的" NOT IN "范围查询的SQL片段.
     * @param field 数据库字段
     * @param values 集合的值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andNotIn(String field, Collection<?> values) {
        return this.doIn(AND_PREFIX, field, values, true, false);
    }

    /**
     * 生成带" AND "前缀的" NOT IN "范围查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param values 集合的值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andNotIn(String field, Collection<?> values, boolean match) {
        return this.doIn(AND_PREFIX, field, values, match, false);
    }

    /**
     * 生成带" OR "前缀的" NOT IN "范围查询的SQL片段.
     * @param field 数据库字段
     * @param values 数组的值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orNotIn(String field, Object[] values) {
        return this.doIn(OR_PREFIX, field, values, true, false);
    }

    /**
     * 生成带" OR "前缀的" NOT IN "范围查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param values 数组的值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orNotIn(String field, Object[] values, boolean match) {
        return this.doIn(OR_PREFIX, field, values, match, false);
    }

    /**
     * 生成带" OR "前缀的" NOT IN "范围查询的SQL片段.
     * @param field 数据库字段
     * @param values 集合的值
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orNotIn(String field, Collection<?> values) {
        return this.doIn(OR_PREFIX, field, values, true, false);
    }

    /**
     * 生成带" OR "前缀的" NOT IN "范围查询的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * @param field 数据库字段
     * @param values 集合的值
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orNotIn(String field, Collection<?> values, boolean match) {
        return this.doIn(OR_PREFIX, field, values, match, false);
    }

    /**
     * 生成" IS NULL "的SQL片段.
     * <p>示例：传入 {"a.name"} 参数，生成的SQL片段为：" a.name IS NULL "</p>
     *
     * @param field 数据库字段
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler isNull(String field) {
        return this.doIsNull(ONE_SPACE, field, true,true);
    }

    /**
     * 生成" IS NULL "的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * <p>示例：传入 {"a.name", true} 两个参数，生成的SQL片段为：" a.name IS NULL "</p>
     *
     * @param field 数据库字段
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler isNull(String field, boolean match) {
        return this.doIsNull(ONE_SPACE, field, match,true);
    }

    /**
     * 生成带" AND "前缀" IS NULL "的SQL片段.
     * <p>示例：传入 {"a.name"} 参数，生成的SQL片段为：" AND a.name IS NULL "</p>
     *
     * @param field 数据库字段
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andIsNull(String field) {
        return this.doIsNull(AND_PREFIX, field, true,true);
    }

    /**
     * 生成带" AND "前缀" IS NULL "的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * <p>示例：传入 {"a.name", true} 两个参数，生成的SQL片段为：" AND a.name IS NULL "</p>
     *
     * @param field 数据库字段
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andIsNull(String field, boolean match) {
        return this.doIsNull(AND_PREFIX, field, match,true);
    }

    /**
     * 生成带" OR "前缀" IS NULL "的SQL片段.
     * <p>示例：传入 {"a.name"} 参数，生成的SQL片段为：" OR a.name IS NULL "</p>
     *
     * @param field 数据库字段
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orIsNull(String field) {
        return this.doIsNull(OR_PREFIX, field, true,true);
    }

    /**
     * 生成带" OR "前缀" IS NULL "的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * <p>示例：传入 {"a.name", true} 两个参数，生成的SQL片段为：" OR a.name IS NULL "</p>
     *
     * @param field 数据库字段
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orIsNull(String field, boolean match) {
        return this.doIsNull(OR_PREFIX, field, match,true);
    }

    /**
     * 生成" IS NOT NULL "的SQL片段.
     * <p>示例：传入 {"a.name"} 参数，生成的SQL片段为：" a.name IS NOT NULL "</p>
     *
     * @param field 数据库字段
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler isNotNull(String field) {
        return this.doIsNull(ONE_SPACE, field, true,false);
    }

    /**
     * 生成" IS NOT NULL "的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * <p>示例：传入 {"a.name", true} 两个参数，生成的SQL片段为：" a.name IS NOT NULL "</p>
     *
     * @param field 数据库字段
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler isNotNull(String field, boolean match) {
        return this.doIsNull(ONE_SPACE, field, match,false);
    }

    /**
     * 生成带" AND "前缀" IS NOT NULL "的SQL片段.
     * <p>示例：传入 {"a.name"} 参数，生成的SQL片段为：" AND a.name IS NOT NULL "</p>
     *
     * @param field 数据库字段
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andIsNotNull(String field) {
        return this.doIsNull(AND_PREFIX, field, true,false);
    }

    /**
     * 生成带" AND "前缀" IS NOT NULL "的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * <p>示例：传入 {"a.name", true} 两个参数，生成的SQL片段为：" AND a.name IS NOT NULL "</p>
     *
     * @param field 数据库字段
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler andIsNotNull(String field, boolean match) {
        return this.doIsNull(AND_PREFIX, field, match,false);
    }

    /**
     * 生成带" OR "前缀" IS NOT NULL "的SQL片段.
     * <p>示例：传入 {"a.name"} 参数，生成的SQL片段为：" OR a.name IS NOT NULL "</p>
     *
     * @param field 数据库字段
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orIsNotNull(String field) {
        return this.doIsNull(OR_PREFIX, field, true,false);
    }

    /**
     * 生成带" OR "前缀" IS NOT NULL "的SQL片段,如果match为true时则生成该条SQL片段，否则不生成.
     * <p>示例：传入 {"a.name", true} 两个参数，生成的SQL片段为：" OR a.name IS NOT NULL "</p>
     *
     * @param field 数据库字段
     * @param match 是否匹配
     * @return SqlBuilderHandler实例
     */
    public SqlBuilderHandler orIsNotNull(String field, boolean match) {
        return this.doIsNull(OR_PREFIX, field, match,false);
    }

}